const express = require('express');
const router = express.Router();
const apiKeyModel = require('./apiKeyModel');
const axios = require('axios');

// 添加新的API密钥
router.post('/api-keys', async (req, res) => {
  try {
    console.log('收到添加API密钥请求:', req.body);
    
    // 检查请求体是否为空
    if (!req.body || Object.keys(req.body).length === 0) {
      console.error('请求体为空');
      return res.status(400).json({ error: '请求体不能为空' });
    }
    
    const { key, provider, endpoint } = req.body;
    
    // 验证必要字段
    if (!key || !provider || !endpoint) {
      console.error('缺少必要字段:', { key: !!key, provider: !!provider, endpoint: !!endpoint });
      return res.status(400).json({ 
        error: '缺少必要字段',
        details: {
          key: !key ? 'API密钥不能为空' : null,
          provider: !provider ? '模型ID不能为空' : null,
          endpoint: !endpoint ? 'API地址不能为空' : null
        }
      });
    }

    // 获取可选的modelName字段
    const { modelName } = req.body;
    console.log('开始添加API密钥...', modelName ? `包含modelName: ${modelName}` : '无modelName');
    
    const id = await apiKeyModel.addApiKey(key, provider, endpoint, modelName);
    console.log('API密钥添加成功, ID:', id);
    
    // 返回成功响应
    res.status(201).json({ 
      id, 
      message: 'API密钥添加成功',
      data: { key, provider, endpoint }
    });
  } catch (error) {
    console.error('添加API密钥失败:', error);
    
    // 返回详细的错误信息
    if (error.message.includes('该API配置已存在')) {
      return res.status(409).json({ error: error.message });
    }
    if (error.message.includes('API密钥不能为空') || 
        error.message.includes('模型ID不能为空') || 
        error.message.includes('API地址不能为空') ||
        error.message.includes('API地址格式无效')) {
      return res.status(400).json({ error: error.message });
    }
    if (error.code === 'ER_BAD_FIELD_ERROR') {
      return res.status(500).json({ 
        error: '数据库字段错误', 
        details: error.message,
        suggestion: '请检查数据库表结构是否正确'
      });
    }
    if (error.code === 'ER_NO_SUCH_TABLE') {
      return res.status(500).json({ 
        error: '数据库表不存在', 
        details: error.message,
        suggestion: '请确保数据库初始化正确'
      });
    }
    
    res.status(500).json({ 
      error: '服务器错误', 
      details: error.message,
      stack: process.env.NODE_ENV === 'development' ? error.stack : undefined
    });
  }
});

// 获取所有API密钥
router.get('/api-keys', async (req, res) => {
  try {
    console.log('收到获取API密钥请求');
    const apiKeys = await apiKeyModel.getAllApiKeys();
    console.log('成功获取API密钥列表，数量:', apiKeys.length);
    res.json(apiKeys);
  } catch (error) {
    console.error('获取API密钥失败:', error);
    
    if (error.code === 'ER_NO_SUCH_TABLE') {
      return res.status(404).json({ 
        error: '数据库表不存在', 
        details: error.message,
        suggestion: '请确保数据库初始化正确'
      });
    }
    
    res.status(500).json({ 
      error: '服务器错误', 
      details: error.message 
    });
  }
});

// 删除API密钥
router.delete('/api-keys/:id', async (req, res) => {
  try {
    const id = req.params.id;
    console.log(`收到删除API密钥请求，ID: ${id}`);
    
    if (!id) {
      return res.status(400).json({ error: 'API密钥ID不能为空' });
    }
    
    await apiKeyModel.deleteApiKey(id);
    console.log(`API密钥(ID: ${id})删除成功`);
    
    res.json({ 
      success: true, 
      message: 'API密钥删除成功',
      id
    });
  } catch (error) {
    console.error(`删除API密钥失败，ID: ${req.params.id}:`, error);
    
    if (error.message.includes('未找到ID')) {
      return res.status(404).json({ error: error.message });
    }
    
    res.status(500).json({ 
      error: '服务器错误', 
      details: error.message 
    });
  }
});

// 测试API配置
router.post('/test-api', async (req, res) => {
  try {
    console.log('收到测试API配置请求:', req.body);
    
    // 检查请求体是否为空
    if (!req.body || Object.keys(req.body).length === 0) {
      console.error('请求体为空');
      return res.status(400).json({ error: '请求体不能为空' });
    }
    
    const { key, provider, endpoint, modelName } = req.body;
    
    // 验证必要字段
    if (!key || !provider || !endpoint) {
      console.error('缺少必要字段:', { key: !!key, provider: !!provider, endpoint: !!endpoint });
      return res.status(400).json({ 
        error: '缺少必要字段',
        details: {
          key: !key ? 'API密钥不能为空' : null,
          provider: !provider ? '模型ID不能为空' : null,
          endpoint: !endpoint ? 'API地址不能为空' : null
        }
      });
    }

    const result = await apiKeyModel.testApiConfig(key, provider, endpoint, modelName);
    console.log('API测试结果:', result);
    
    if (result.success) {
      res.json({
        success: true,
        message: result.message,
        data: result.data || {}
      });
    } else {
      res.status(400).json({
        success: false,
        message: result.message,
        error: result.error
      });
    }
  } catch (error) {
    console.error('API测试失败:', error);
    res.status(500).json({ 
      error: '服务器错误', 
      message: error.message,
      details: process.env.NODE_ENV === 'development' ? error.stack : undefined
    });
  }
});

// 处理聊天请求 - 新增
router.post('/chat', async (req, res) => {
  try {
    console.log('收到聊天请求:', { body: req.body });
    
    // 检查请求体
    if (!req.body || Object.keys(req.body).length === 0) {
      return res.status(400).json({ error: '请求体不能为空' });
    }
    
    const { apiKeyId, messages } = req.body;
    
    // 验证必要字段
    if (!apiKeyId) {
      return res.status(400).json({ error: 'API密钥ID不能为空' });
    }
    
    if (!messages || !Array.isArray(messages) || messages.length === 0) {
      return res.status(400).json({ error: '消息不能为空或格式错误' });
    }
    
    // 获取API密钥配置
    const pool = apiKeyModel.getPool();
    const [apiKeys] = await pool.query('SELECT * FROM api_keys WHERE id = ?', [apiKeyId]);
    
    if (apiKeys.length === 0) {
      return res.status(404).json({ error: `未找到ID为 ${apiKeyId} 的API密钥配置` });
    }
    
    const apiConfig = apiKeys[0];
    console.log('使用API配置:', { id: apiConfig.id, provider: apiConfig.provider, endpoint: apiConfig.endpoint });
    
    // 清理并格式化endpoint，确保它是以/结尾的有效URL
    let cleanEndpoint = apiConfig.endpoint.trim();
    if (!cleanEndpoint.endsWith('/')) {
      cleanEndpoint += '/';
    }
    
    // 构建完整的API URL
    const apiUrl = `${cleanEndpoint}v1/chat/completions`;
    console.log('请求URL:', apiUrl);
    
    // 创建请求数据
    const requestData = {
      model: apiConfig.provider,
      messages: messages,
      temperature: 0.7,
      max_tokens: 2000
    };
    
    // 创建请求配置
    const config = {
      headers: {
        'Authorization': `Bearer ${apiConfig.key}`,
        'Content-Type': 'application/json'
      },
      timeout: 60000 // 60秒超时
    };
    
    // 发送请求到AI服务提供商
    console.log('发送请求到AI服务提供商...');
    const response = await axios.post(apiUrl, requestData, config);
    console.log('收到AI服务提供商响应:', { 
      status: response.status, 
      model: response.data?.model, 
      choices: response.data?.choices?.length
    });
    
    // 返回AI服务提供商的响应
    res.json(response.data);
  } catch (error) {
    console.error('聊天请求处理失败:', error);
    
    // 处理不同类型的错误
    if (error.response) {
      // AI服务提供商返回的错误
      const statusCode = error.response.status;
      const errorData = error.response.data;
      
      console.error('AI服务提供商返回错误:', {
        status: statusCode,
        data: errorData
      });
      
      // 将原始错误转发回客户端
      return res.status(statusCode).json({
        error: '与AI服务通信失败',
        details: errorData
      });
    } else if (error.code === 'ECONNABORTED') {
      return res.status(504).json({ error: '连接超时，请检查API地址或网络状态' });
    } else if (error.code === 'ENOTFOUND') {
      return res.status(502).json({ error: '无法解析API地址，请检查URL是否正确' });
    }
    
    // 其他服务器内部错误
    res.status(500).json({
      error: '服务器错误',
      message: error.message,
      details: process.env.NODE_ENV === 'development' ? error.stack : undefined
    });
  }
});

module.exports = router; 